home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1994 / 8 / 05 / term-4.0-source.lha / termUploadQueue.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-11  |  27.5 KB  |  1,366 lines
  1. /*
  2. **    termUploadQueue.c
  3. **
  4. **    Upload queue user interface.
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LIST=1000,GAD_NAME,
  13.         GAD_ADD,GAD_REMOVE,GAD_CLEAR,GAD_HIDE,
  14.         GAD_ADD_FILES
  15.     };
  16.  
  17. enum    {    APP_ICON=1,APP_WINDOW=2 };
  18.  
  19. STATIC struct List    *TransferList;
  20. STATIC struct Node    *TransferNode;
  21. STATIC LONG         TransferOffset,
  22.              TransferCount;
  23. STATIC struct MsgPort    *TransferPort;
  24.  
  25. STATIC struct Process    *TransferProcess;
  26.  
  27.     /* QueuePanel(struct Window *Window):
  28.      *
  29.      *    Create the user interface for the queue panel.
  30.      */
  31.  
  32. STATIC LayoutHandle *
  33. QueuePanel(struct Window *Window)
  34. {
  35.     LayoutHandle *Handle;
  36.  
  37.     TransferNode    = NULL;
  38.     TransferOffset    = -1;
  39.     TransferCount    = GetListSize(TransferList);
  40.  
  41.     if(Handle = LT_CreateHandleTags(Window ? Window -> WScreen : NULL,
  42.         LH_LocaleHook,    &LocaleHook,
  43.     TAG_DONE))
  44.     {
  45.         LT_New(Handle,
  46.             LA_Type,    VERTICAL_KIND,
  47.         TAG_DONE);
  48.         {
  49.             LT_New(Handle,
  50.                 LA_Type,    VERTICAL_KIND,
  51.             TAG_DONE);
  52.             {
  53.                 LT_New(Handle,
  54.                     LA_Type,    LISTVIEW_KIND,
  55.                     LA_LabelID,    MSG_UPLOADQUEUE_FILES_TO_UPLOAD_TXT,
  56.                     LA_LabelPlace,    PLACE_ABOVE,
  57.                     LA_Chars,    30,
  58.                     LA_Lines,    10,
  59.                     LA_ID,        GAD_LIST,
  60.                     LALV_CursorKey,    TRUE,
  61.                     LALV_MaxGrowY,    20,
  62.                     LALV_MaxGrowX,    50,
  63.                     GTLV_Labels,    TransferList,
  64.  
  65.                     Kick30 ? LALV_Link : TAG_IGNORE,NIL_LINK,
  66.                 TAG_DONE);
  67.  
  68.                 LT_New(Handle,
  69.                     LA_Type,    STRING_KIND,
  70.                     LA_ID,        GAD_NAME,
  71.                     GTST_MaxChars,    255,
  72.                     LAST_Picker,    TRUE,
  73.                 TAG_DONE);
  74.  
  75.                 LT_EndGroup(Handle);
  76.             }
  77.  
  78.             LT_New(Handle,
  79.                 LA_Type,    HORIZONTAL_KIND,
  80.                 LA_LabelID,    MSG_V36_0043,
  81.                 LA_SameSize,    TRUE,
  82.             TAG_DONE);
  83.             {
  84.                 LT_New(Handle,
  85.                     LA_Type,    BUTTON_KIND,
  86.                     LA_LabelID,    MSG_ADD_SEVERAL_FILES_TXT,
  87.                     LA_ID,        GAD_ADD_FILES,
  88.                 TAG_DONE);
  89.  
  90.                 LT_New(Handle,
  91.                     LA_Type,    BUTTON_KIND,
  92.                     LA_LabelID,    MSG_UPLOADQUEUE_ADD_TXT,
  93.                     LA_ID,        GAD_ADD,
  94.                 TAG_DONE);
  95.  
  96.                 LT_New(Handle,
  97.                     LA_Type,    BUTTON_KIND,
  98.                     LA_LabelID,    MSG_UPLOADQUEUE_REMOVE_TXT,
  99.                     LA_ID,        GAD_REMOVE,
  100.                     GA_Disabled,    TRUE,
  101.                 TAG_DONE);
  102.  
  103.                 LT_New(Handle,
  104.                     LA_Type,    BUTTON_KIND,
  105.                     LA_LabelID,    MSG_UPLOADQUEUE_CLEAR_TXT,
  106.                     LA_ID,        GAD_CLEAR,
  107.                     GA_Disabled,    !TransferCount,
  108.                 TAG_DONE);
  109.  
  110.                 LT_EndGroup(Handle);
  111.             }
  112.  
  113.             LT_New(Handle,
  114.                 LA_Type,    VERTICAL_KIND,
  115.             TAG_DONE);
  116.             {
  117.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  118.  
  119.                 LT_EndGroup(Handle);
  120.             }
  121.  
  122.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  123.                 LAGR_SameSize,    TRUE,
  124.             TAG_DONE);
  125.             {
  126.                 LT_New(Handle,
  127.                     LA_Type,    BUTTON_KIND,
  128.                     LA_LabelID,    MSG_UPLOADQUEUE_BINARY_UPLOAD_TXT,
  129.                     LA_ID,        UPLOAD_BINARY,
  130.                     LABT_ExtraFat,    TRUE,
  131.                     LABT_ReturnKey,    TRUE,
  132.                     GA_Disabled,    !TransferCount,
  133.                 TAG_DONE);
  134.  
  135.                 LT_New(Handle,
  136.                     LA_Type,    BUTTON_KIND,
  137.                     LA_LabelID,    MSG_UPLOADQUEUE_TEXT_UPLOAD_TXT,
  138.                     LA_ID,        UPLOAD_TEXT,
  139.                     GA_Disabled,    !TransferCount,
  140.                 TAG_DONE);
  141.  
  142.                 LT_New(Handle,
  143.                     LA_Type,    BUTTON_KIND,
  144.                     LA_LabelID,    MSG_UPLOADQUEUE_HIDE_TXT,
  145.                     LA_ID,        GAD_HIDE,
  146.                     LABT_EscKey,    TRUE,
  147.                 TAG_DONE);
  148.  
  149.                 LT_EndGroup(Handle);
  150.             }
  151.  
  152.             LT_EndGroup(Handle);
  153.         }
  154.  
  155.         if(LT_Layout(Handle,LocaleString(MSG_UPLOADQUEUE_FILE_UPLOAD_LIST_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  156.             WA_DepthGadget,        TRUE,
  157.             WA_CloseGadget,        TRUE,
  158.             WA_DragBar,        TRUE,
  159.             WA_RMBTrap,        TRUE,
  160.             WA_Activate,        TRUE,
  161.             LAWN_BelowMouse,    TRUE,
  162.         TAG_DONE))
  163.             return(Handle);
  164.  
  165.         LT_DeleteHandle(Handle);
  166.     }
  167.  
  168.     return(NULL);
  169. }
  170.  
  171.     /* HandleQueueWindow(LayoutHandle *Handle):
  172.      *
  173.      *    Process queue panel messages.
  174.      */
  175.  
  176. STATIC LONG __regargs
  177. HandleQueueWindow(LayoutHandle *Handle)
  178. {
  179.     struct IntuiMessage    *Message;
  180.     ULONG             MsgClass,
  181.                  MsgQualifier;
  182.     UWORD             MsgCode;
  183.     struct Gadget        *MsgGadget;
  184.  
  185.     struct Node        *Node;
  186.  
  187.     struct Window        *Window = Handle -> Window;
  188.     LONG             Result = 0;
  189.  
  190.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  191.                 *DummyChar;
  192.     struct FileRequester    *FileRequest;
  193.  
  194.     while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  195.     {
  196.         MsgClass    = Message -> Class;
  197.         MsgQualifier    = Message -> Qualifier;
  198.         MsgCode        = Message -> Code;
  199.         MsgGadget    = (struct Gadget *)Message -> IAddress;
  200.  
  201.         GT_ReplyIMsg(Message);
  202.  
  203.         LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  204.  
  205.         if(MsgClass == IDCMP_CLOSEWINDOW)
  206.             Result = GAD_HIDE;
  207.  
  208.         if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_NAME)
  209.         {
  210.             LT_LockWindow(Window);
  211.  
  212.             SplitFileName(LT_GetString(Handle,GAD_NAME),&DummyChar,DummyBuffer);
  213.  
  214.             if(FileRequest = GetFile(Window,LocaleString(MSG_UPLOADQUEUE_SELECT_FILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),FALSE))
  215.             {
  216.                 LT_SetAttributes(Handle,GAD_NAME,
  217.                     GTST_String,    DummyBuffer,
  218.                 TAG_DONE);
  219.             }
  220.  
  221.             LT_UnlockWindow(Window);
  222.  
  223.             LT_Activate(Handle,GAD_NAME);
  224.         }
  225.  
  226.         if(MsgClass == IDCMP_GADGETUP)
  227.         {
  228.             switch(MsgGadget -> GadgetID)
  229.             {
  230.                 case GAD_ADD_FILES:
  231.  
  232.                     LT_LockWindow(Window);
  233.  
  234.                     if(!GetCurrentDirName(DummyBuffer,MAX_FILENAME_LENGTH))
  235.                         DummyBuffer[0] = 0;
  236.  
  237.                     if(FileRequest = AllocAslRequestTags(ASL_FileRequest,
  238.                         ASL_Window,    Window,
  239.                         ASL_Hail,    LocaleString(MSG_ADD_FILES_TITLE_TXT),
  240.                         ASL_FuncFlags,    FILF_MULTISELECT,
  241.                         ASL_OKText,    LocaleString(MSG_ADD_GAD),
  242.                         ASL_CancelText,    LocaleString(MSG_DONE_GAD),
  243.                         ASL_Dir,    DummyBuffer,
  244.                         ASLFR_TextAttr,    &UserFont,
  245.                     TAG_DONE))
  246.                     {
  247.                         LONG i;
  248.  
  249.                         LT_SetAttributes(Handle,GAD_LIST,
  250.                             GTLV_Labels,    ~0,
  251.                         TAG_DONE);
  252.  
  253.                         while(AslRequestTags(FileRequest,TAG_DONE))
  254.                         {
  255.                             for(i = 0 ; i < FileRequest -> rf_NumArgs ; i++)
  256.                             {
  257.                                 if(FileRequest -> fr_ArgList[i] . wa_Lock)
  258.                                 {
  259.                                     if(!NameFromLock(FileRequest -> fr_ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  260.                                         DummyBuffer[0] = 0;
  261.                                 }
  262.                                 else
  263.                                     strcpy(DummyBuffer,FileRequest -> fr_Drawer);
  264.  
  265.                                 if(FileRequest -> fr_ArgList[i] . wa_Name)
  266.                                 {
  267.                                     if(!AddPart(DummyBuffer,FileRequest -> fr_ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  268.                                         DummyBuffer[0] = 0;
  269.                                 }
  270.  
  271.                                 if(DummyBuffer[0])
  272.                                 {
  273.                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  274.                                     {
  275.                                         Node -> ln_Name = (STRPTR)(Node + 1);
  276.  
  277.                                         strcpy(Node -> ln_Name,DummyBuffer);
  278.  
  279.                                         AddTail(TransferList,Node);
  280.  
  281.                                         TransferNode = Node;
  282.                                         TransferOffset = TransferCount++;
  283.                                     }
  284.                                 }
  285.                             }
  286.  
  287.                             LT_SetAttributes(Handle,GAD_LIST,
  288.                                 GTLV_Labels,    TransferList,
  289.                                 GTLV_Selected,    TransferOffset,
  290.                             TAG_DONE);
  291.                         }
  292.  
  293.                         LT_SetAttributes(Handle,GAD_LIST,
  294.                             GTLV_Labels,    TransferList,
  295.                             GTLV_Selected,    TransferOffset,
  296.                         TAG_DONE);
  297.  
  298.                         if(TransferCount)
  299.                         {
  300.                             LT_SetAttributes(Handle,GAD_NAME,
  301.                                 GTST_String,    "",
  302.                             TAG_DONE);
  303.  
  304.                             LT_SetAttributes(Handle,GAD_REMOVE,
  305.                                 GA_Disabled,    FALSE,
  306.                             TAG_DONE);
  307.  
  308.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  309.                                 GA_Disabled,    FALSE,
  310.                             TAG_DONE);
  311.  
  312.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  313.                                 GA_Disabled,    FALSE,
  314.                             TAG_DONE);
  315.  
  316.                             LT_SetAttributes(Handle,GAD_CLEAR,
  317.                                 GA_Disabled,    FALSE,
  318.                             TAG_DONE);
  319.                         }
  320.  
  321.                         FreeAslRequest(FileRequest);
  322.                     }
  323.                         
  324.                     LT_UnlockWindow(Window);
  325.                     break;
  326.  
  327.                 case GAD_ADD:
  328.  
  329.                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  330.                     {
  331.                         Node -> ln_Name = (STRPTR)(Node + 1);
  332.  
  333.                         Node -> ln_Name[0] = 0;
  334.  
  335.                         LT_SetAttributes(Handle,GAD_LIST,
  336.                             GTLV_Labels,    ~0,
  337.                         TAG_DONE);
  338.  
  339.                         AddTail(TransferList,Node);
  340.  
  341.                         LT_SetAttributes(Handle,GAD_LIST,
  342.                             GTLV_Labels,    TransferList,
  343.                             GTLV_Selected,    TransferOffset = TransferCount++,
  344.                         TAG_DONE);
  345.  
  346.                         LT_SetAttributes(Handle,GAD_NAME,
  347.                             GTST_String,    "",
  348.                         TAG_DONE);
  349.  
  350.                         LT_SetAttributes(Handle,GAD_REMOVE,
  351.                             GA_Disabled,    FALSE,
  352.                         TAG_DONE);
  353.  
  354.                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  355.                             GA_Disabled,    FALSE,
  356.                         TAG_DONE);
  357.  
  358.                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  359.                             GA_Disabled,    FALSE,
  360.                         TAG_DONE);
  361.  
  362.                         LT_SetAttributes(Handle,GAD_CLEAR,
  363.                             GA_Disabled,    FALSE,
  364.                         TAG_DONE);
  365.  
  366.                         TransferNode = Node;
  367.  
  368.                         LT_Activate(Handle,GAD_NAME);
  369.                     }
  370.                     else
  371.                         DisplayBeep(Window -> WScreen);
  372.  
  373.                     break;
  374.  
  375.                 case GAD_REMOVE:
  376.  
  377.                     if(TransferNode)
  378.                     {
  379.                         LT_SetAttributes(Handle,GAD_LIST,
  380.                             GTLV_Labels,    ~0,
  381.                         TAG_DONE);
  382.  
  383.                         if(--TransferCount)
  384.                         {
  385.                             if(TransferNode -> ln_Succ -> ln_Succ)
  386.                                 Node = TransferNode -> ln_Succ;
  387.                             else
  388.                             {
  389.                                 if(TransferNode -> ln_Pred -> ln_Pred)
  390.                                 {
  391.                                     Node = TransferNode -> ln_Pred;
  392.  
  393.                                     TransferOffset--;
  394.                                 }
  395.                                 else
  396.                                 {
  397.                                     TransferOffset = -1;
  398.  
  399.                                     Node = NULL;
  400.                                 }
  401.                             }
  402.                         }
  403.                         else
  404.                         {
  405.                             TransferOffset = -1;
  406.  
  407.                             Node = NULL;
  408.                         }
  409.  
  410.                         Remove(TransferNode);
  411.  
  412.                         FreeVecPooled(TransferNode);
  413.  
  414.                         TransferNode = Node;
  415.  
  416.                         LT_SetAttributes(Handle,GAD_LIST,
  417.                             GTLV_Labels,    TransferList,
  418.                             GTLV_Selected,    TransferOffset,
  419.                         TAG_DONE);
  420.  
  421.                         if(!TransferCount)
  422.                         {
  423.                             LT_SetAttributes(Handle,GAD_REMOVE,
  424.                                 GA_Disabled,    TRUE,
  425.                             TAG_DONE);
  426.  
  427.                             LT_SetAttributes(Handle,GAD_NAME,
  428.                                 GTST_String,    "",
  429.                             TAG_DONE);
  430.  
  431.                             LT_SetAttributes(Handle,GAD_CLEAR,
  432.                                 GA_Disabled,    TRUE,
  433.                             TAG_DONE);
  434.  
  435.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  436.                                 GA_Disabled,    TRUE,
  437.                             TAG_DONE);
  438.  
  439.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  440.                                 GA_Disabled,    TRUE,
  441.                             TAG_DONE);
  442.                         }
  443.                         else
  444.                         {
  445.                             LT_SetAttributes(Handle,GAD_NAME,
  446.                                 GTST_String,    TransferNode -> ln_Name,
  447.                             TAG_DONE);
  448.                         }
  449.                     }
  450.  
  451.                     break;
  452.  
  453.                 case GAD_LIST:
  454.  
  455.                     if(TransferNode = (struct Node *)GetListNode(MsgCode,TransferList))
  456.                     {
  457.                         TransferOffset = MsgCode;
  458.  
  459.                         LT_SetAttributes(Handle,GAD_NAME,
  460.                             GTST_String,    TransferNode -> ln_Name,
  461.                         TAG_DONE);
  462.  
  463.                         LT_SetAttributes(Handle,GAD_REMOVE,
  464.                             GA_Disabled,    FALSE,
  465.                         TAG_DONE);
  466.                     }
  467.  
  468.                     break;
  469.  
  470.                 case GAD_NAME:
  471.  
  472.                     if(TransferNode)
  473.                     {
  474.                         LT_SetAttributes(Handle,GAD_LIST,
  475.                             GTLV_Labels,    ~0,
  476.                         TAG_DONE);
  477.  
  478.                         strcpy(TransferNode -> ln_Name,LT_GetString(Handle,GAD_NAME));
  479.  
  480.                         LT_SetAttributes(Handle,GAD_LIST,
  481.                             GTLV_Labels,    TransferList,
  482.                             GTLV_Selected,    ~0,
  483.                         TAG_DONE);
  484.                     }
  485.                     else
  486.                     {
  487.                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  488.                         {
  489.                             Node -> ln_Name = (STRPTR)(Node + 1);
  490.  
  491.                             strcpy(Node -> ln_Name,LT_GetString(Handle,GAD_NAME));
  492.  
  493.                             LT_SetAttributes(Handle,GAD_LIST,
  494.                                 GTLV_Labels,    ~0,
  495.                             TAG_DONE);
  496.  
  497.                             AddTail(TransferList,Node);
  498.  
  499.                             TransferCount++;
  500.  
  501.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  502.                                 GA_Disabled,    FALSE,
  503.                             TAG_DONE);
  504.  
  505.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  506.                                 GA_Disabled,    FALSE,
  507.                             TAG_DONE);
  508.  
  509.                             LT_SetAttributes(Handle,GAD_CLEAR,
  510.                                 GA_Disabled,    FALSE,
  511.                             TAG_DONE);
  512.  
  513.                             LT_SetAttributes(Handle,GAD_LIST,
  514.                                 GTLV_Labels,        TransferList,
  515.                                 GTLV_Selected,        ~0,
  516.                                 GTLV_MakeVisible,    TransferCount - 1,
  517.                             TAG_DONE);
  518.                         }
  519.                     }
  520.  
  521.                     LT_SetAttributes(Handle,GAD_REMOVE,
  522.                         GA_Disabled,    TRUE,
  523.                     TAG_DONE);
  524.  
  525.                     LT_SetAttributes(Handle,GAD_NAME,
  526.                         GTST_String,    "",
  527.                     TAG_DONE);
  528.  
  529.                     TransferNode    = NULL;
  530.                     TransferOffset    = -1;
  531.  
  532.                     break;
  533.  
  534.                 case GAD_CLEAR:
  535.  
  536.                     LT_SetAttributes(Handle,GAD_LIST,
  537.                         GTLV_Labels,    ~0,
  538.                     TAG_DONE);
  539.  
  540.                     TransferCount    = 0;
  541.                     TransferOffset    = -1;
  542.                     TransferNode    = NULL;
  543.  
  544.                     FreeList(TransferList);
  545.  
  546.                     LT_SetAttributes(Handle,GAD_REMOVE,
  547.                         GA_Disabled,    TRUE,
  548.                     TAG_DONE);
  549.  
  550.                     LT_SetAttributes(Handle,GAD_NAME,
  551.                         GTST_String,    "",
  552.                     TAG_DONE);
  553.  
  554.                     LT_SetAttributes(Handle,GAD_CLEAR,
  555.                         GA_Disabled,    TRUE,
  556.                     TAG_DONE);
  557.  
  558.                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  559.                         GA_Disabled,    TRUE,
  560.                     TAG_DONE);
  561.  
  562.                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  563.                         GA_Disabled,    TRUE,
  564.                     TAG_DONE);
  565.  
  566.                     LT_SetAttributes(Handle,GAD_LIST,
  567.                         GTLV_Labels,    TransferList,
  568.                         GTLV_Selected,    ~0,
  569.                     TAG_DONE);
  570.  
  571.                     break;
  572.  
  573.                 case UPLOAD_BINARY:
  574.                 case UPLOAD_TEXT:
  575.                 case GAD_HIDE:
  576.  
  577.                     Result = MsgGadget -> GadgetID;
  578.                     break;
  579.             }
  580.         }
  581.     }
  582.  
  583.     return(Result);
  584. }
  585.  
  586.     /* QueueClientDestructor(struct DataMsg *Item):
  587.      *
  588.      *    Local msgitem destructor.
  589.      */
  590.  
  591. STATIC VOID __stdargs
  592. QueueClientDestructor(struct DataMsg *Item)
  593. {
  594.     Signal(TransferProcess,SIG_HANDSHAKE);
  595. }
  596.  
  597.     /* QueueEntry(VOID):
  598.      *
  599.      *    The entry point for the queue process.
  600.      */
  601.  
  602. STATIC VOID __saveds
  603. QueueEntry(VOID)
  604. {
  605.     if(TransferList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  606.     {
  607.         if(TransferPort = CreateMsgPort())
  608.         {
  609.             struct MsgPort        *AppPort;
  610.             struct AppIcon        *AppIcon;
  611.             struct AppWindow    *AppWindow;
  612.             APTR             OldPtr;
  613.  
  614.             NewList(TransferList);
  615.  
  616.             TransferNode    = NULL;
  617.             TransferOffset    = -1;
  618.  
  619.             if(AppPort = CreateMsgPort())
  620.             {
  621.                 ULONG             Signals;
  622.                 BOOLEAN             Done = FALSE;
  623.                 LayoutHandle        *Handle;
  624.                 struct Window        *LocalWindow;
  625.                 ULONG             WindowMask,
  626.                              TransferMask;
  627.                 struct AppMessage    *AppMessage;
  628.                 struct DiskObject    *LoadedIcon = NULL;
  629.  
  630.                 if(WorkbenchBase)
  631.                 {
  632.                     if(IconBase)
  633.                         LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  634.  
  635.                     AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  636.                 }
  637.                 else
  638.                     AppIcon = NULL;
  639.  
  640.                 AppWindow    = NULL;
  641.                 WindowMask    = NULL;
  642.                 Handle        = NULL;
  643.                 LocalWindow    = NULL;
  644.                 TransferMask    = PORTMASK(TransferPort);
  645.  
  646.                 TransferProcess = (struct Process *)FindTask(NULL);
  647.  
  648.                 OldPtr = TransferProcess -> pr_WindowPtr;
  649.  
  650.                 Signal(ThisProcess,SIG_HANDSHAKE);
  651.  
  652.                 do
  653.                 {
  654.                     Signals = Wait(SIG_KILL | SIG_SHOW | SIG_HIDE | SIG_GOAWAY | WindowMask | TransferMask | PORTMASK(AppPort));
  655.  
  656.                     if(Signals & TransferMask)
  657.                     {
  658.                         struct Message *Message;
  659.  
  660.                         while(Message = GetMsg(TransferPort))
  661.                         {
  662.                             if(Message -> mn_Node . ln_Name == (APTR)1)
  663.                             {
  664.                                 Message -> mn_Node . ln_Name = NULL;
  665.  
  666.                                 if(TransferList -> lh_Head -> ln_Succ)
  667.                                 {
  668.                                     struct List *List;
  669.  
  670.                                     if(Handle)
  671.                                     {
  672.                                         LT_SetAttributes(Handle,GAD_LIST,
  673.                                             GTLV_Labels,    ~0,
  674.                                         TAG_DONE);
  675.                                     }
  676.  
  677.                                     if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  678.                                     {
  679.                                         struct Node *Node,*Next;
  680.  
  681.                                         NewList(List);
  682.  
  683.                                         for(Node = TransferList -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
  684.                                         {
  685.                                             Remove(Node);
  686.  
  687.                                             AddTail(List,Node);
  688.                                         }
  689.  
  690.                                         Message -> mn_Node . ln_Name = (STRPTR)List;
  691.                                     }
  692.  
  693.                                     if(Handle)
  694.                                     {
  695.                                         TransferCount = GetListSize(TransferList);
  696.     
  697.                                         TransferOffset    = -1;
  698.                                         TransferNode    = NULL;
  699.     
  700.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  701.                                             GA_Disabled,    TRUE,
  702.                                         TAG_DONE);
  703.     
  704.                                         LT_SetAttributes(Handle,GAD_NAME,
  705.                                             GTST_String,    "",
  706.                                         TAG_DONE);
  707.     
  708.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  709.                                             GA_Disabled,    !TransferCount,
  710.                                         TAG_DONE);
  711.     
  712.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  713.                                             GA_Disabled,    !TransferCount,
  714.                                         TAG_DONE);
  715.     
  716.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  717.                                             GA_Disabled,    !TransferCount,
  718.                                         TAG_DONE);
  719.     
  720.                                         LT_SetAttributes(Handle,GAD_LIST,
  721.                                             GTLV_Labels,    TransferList,
  722.                                         TAG_DONE);
  723.                                     }
  724.                                 }
  725.  
  726.                                 ReplyMsg(Message);
  727.  
  728.                                 continue;
  729.                             }
  730.  
  731.                                 // Check to see if there is anything in the list?
  732.  
  733.                             if(Message -> mn_Node . ln_Name == (APTR)~0)
  734.                             {
  735.                                 if(TransferList -> lh_Head -> ln_Succ)
  736.                                     Message -> mn_Node . ln_Name = (APTR)TRUE;
  737.                                 else
  738.                                     Message -> mn_Node . ln_Name = (APTR)FALSE;
  739.  
  740.                                 ReplyMsg(Message);
  741.                             }
  742.                             else
  743.                             {
  744.                                 UBYTE        Type = (UBYTE)Message -> mn_Node . ln_Name[0];
  745.                                 struct DataMsg    Msg;
  746.  
  747.                                 ReplyMsg(Message);
  748.  
  749.                                 InitMsgItem(&Msg,QueueClientDestructor);
  750.  
  751.                                 Msg . Type = DATAMSGTYPE_UPLOAD;
  752.                                 Msg . Data = (UBYTE *)TransferList;
  753.                                 Msg . Size = Type;
  754.  
  755.                                 if(Handle)
  756.                                 {
  757.                                     LT_SetAttributes(Handle,GAD_LIST,
  758.                                         GTLV_Labels,    ~0,
  759.                                     TAG_DONE);
  760.  
  761.                                     LT_LockWindow(LocalWindow);
  762.                                 }
  763.  
  764.                                 Forbid();
  765.  
  766.                                 PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  767.  
  768.                                 ClrSignal(SIG_HANDSHAKE);
  769.  
  770.                                 Wait(SIG_HANDSHAKE);
  771.  
  772.                                 Permit();
  773.  
  774.                                 if(Handle)
  775.                                 {
  776.                                     TransferCount = GetListSize(TransferList);
  777.  
  778.                                     TransferOffset    = -1;
  779.                                     TransferNode    = NULL;
  780.  
  781.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  782.                                         GA_Disabled,    TRUE,
  783.                                     TAG_DONE);
  784.  
  785.                                     LT_SetAttributes(Handle,GAD_NAME,
  786.                                         GTST_String,    "",
  787.                                     TAG_DONE);
  788.  
  789.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  790.                                         GA_Disabled,    !TransferCount,
  791.                                     TAG_DONE);
  792.  
  793.                                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  794.                                         GA_Disabled,    !TransferCount,
  795.                                     TAG_DONE);
  796.  
  797.                                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  798.                                         GA_Disabled,    !TransferCount,
  799.                                     TAG_DONE);
  800.  
  801.                                     LT_SetAttributes(Handle,GAD_LIST,
  802.                                         GTLV_Labels,    TransferList,
  803.                                     TAG_DONE);
  804.  
  805.                                     LT_UnlockWindow(LocalWindow);
  806.                                 }
  807.                             }
  808.                         }
  809.                     }
  810.  
  811.                     if(Signals & SIG_HIDE)
  812.                     {
  813.                         if(AppWindow)
  814.                         {
  815.                             RemoveAppWindow(AppWindow);
  816.  
  817.                             AppWindow = NULL;
  818.                         }
  819.  
  820.                         if(Handle)
  821.                         {
  822.                             LT_DeleteHandle(Handle);
  823.  
  824.                             Handle = NULL;
  825.                         }
  826.  
  827.                         WindowMask    = NULL;
  828.                         LocalWindow    = NULL;
  829.  
  830.                         TransferProcess -> pr_WindowPtr = OldPtr;
  831.  
  832.                         Signal(ThisProcess,SIG_HANDSHAKE);
  833.                     }
  834.  
  835.                     if(Signals & SIG_GOAWAY)
  836.                     {
  837.                         if(Handle)
  838.                         {
  839.                             if(LocalWindow -> WScreen == Screen)
  840.                             {
  841.                                 if(AppWindow)
  842.                                 {
  843.                                     RemoveAppWindow(AppWindow);
  844.  
  845.                                     AppWindow = NULL;
  846.                                 }
  847.  
  848.                                 LT_DeleteHandle(Handle);
  849.  
  850.                                 Handle        = NULL;
  851.                                 WindowMask    = NULL;
  852.                                 LocalWindow    = NULL;
  853.  
  854.                                 TransferProcess -> pr_WindowPtr = OldPtr;
  855.                             }
  856.                         }
  857.  
  858.                         Signal(ThisProcess,SIG_HANDSHAKE);
  859.                     }
  860.  
  861.                     if(Signals & SIG_KILL)
  862.                         break;
  863.  
  864.                     if(Signals & SIG_SHOW)
  865.                     {
  866.                         if(!Handle)
  867.                         {
  868.                             Forbid();
  869.  
  870.                             if(Handle = QueuePanel(Window))
  871.                             {
  872.                                 Permit();
  873.  
  874.                                 if(WorkbenchBase)
  875.                                     AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  876.                                 else
  877.                                     AppWindow = NULL;
  878.  
  879.                                 LocalWindow    = Handle -> Window;
  880.                                 WindowMask    = PORTMASK(LocalWindow -> UserPort);
  881.  
  882.                                 TransferProcess -> pr_WindowPtr = LocalWindow;
  883.                             }
  884.                             else
  885.                                 Permit();
  886.                         }
  887.  
  888.                         if(Handle)
  889.                             LT_ShowWindow(Handle,TRUE);
  890.                     }
  891.  
  892.                     if(Signals & WindowMask)
  893.                     {
  894.                         struct DataMsg    Msg;
  895.                         LONG        Type;
  896.  
  897.                         switch(Type = HandleQueueWindow(Handle))
  898.                         {
  899.                             case GAD_HIDE:
  900.  
  901.                                 if(AppWindow)
  902.                                 {
  903.                                     RemoveAppWindow(AppWindow);
  904.  
  905.                                     AppWindow = NULL;
  906.                                 }
  907.  
  908.                                 if(Handle)
  909.                                 {
  910.                                     LT_DeleteHandle(Handle);
  911.  
  912.                                     Handle = NULL;
  913.                                 }
  914.  
  915.                                 TransferProcess -> pr_WindowPtr = OldPtr;
  916.  
  917.                                 WindowMask    = NULL;
  918.                                 LocalWindow    = NULL;
  919.  
  920.                                 break;
  921.  
  922.                             case UPLOAD_BINARY:
  923.                             case UPLOAD_TEXT:
  924.  
  925.                                 InitMsgItem(&Msg,QueueClientDestructor);
  926.  
  927.                                 Msg . Type = DATAMSGTYPE_UPLOAD;
  928.                                 Msg . Data = (UBYTE *)TransferList;
  929.                                 Msg . Size = Type;
  930.  
  931.                                 if(Handle)
  932.                                 {
  933.                                     LT_SetAttributes(Handle,GAD_LIST,
  934.                                         GTLV_Labels,    ~0,
  935.                                     TAG_DONE);
  936.  
  937.                                     LT_LockWindow(LocalWindow);
  938.                                 }
  939.  
  940.                                 Forbid();
  941.  
  942.                                 PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  943.  
  944.                                 ClrSignal(SIG_HANDSHAKE);
  945.  
  946.                                 Wait(SIG_HANDSHAKE);
  947.  
  948.                                 Permit();
  949.  
  950.                                 if(Handle)
  951.                                 {
  952.                                     TransferCount = GetListSize(TransferList);
  953.  
  954.                                     TransferOffset    = -1;
  955.                                     TransferNode    = NULL;
  956.  
  957.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  958.                                         GA_Disabled,    TRUE,
  959.                                     TAG_DONE);
  960.  
  961.                                     LT_SetAttributes(Handle,GAD_NAME,
  962.                                         GTST_String,    "",
  963.                                     TAG_DONE);
  964.  
  965.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  966.                                         GA_Disabled,    !TransferCount,
  967.                                     TAG_DONE);
  968.  
  969.                                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  970.                                         GA_Disabled,    !TransferCount,
  971.                                     TAG_DONE);
  972.  
  973.                                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  974.                                         GA_Disabled,    !TransferCount,
  975.                                     TAG_DONE);
  976.  
  977.                                     LT_SetAttributes(Handle,GAD_LIST,
  978.                                         GTLV_Labels,    TransferList,
  979.                                     TAG_DONE);
  980.  
  981.                                     LT_UnlockWindow(LocalWindow);
  982.                                 }
  983.  
  984.                                 break;
  985.                         }
  986.                     }
  987.  
  988.                     if(Signals & PORTMASK(AppPort))
  989.                     {
  990.                         while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  991.                         {
  992.                             if(AppMessage -> am_Type == AMTYPE_APPWINDOW && Handle)
  993.                             {
  994.                                 UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  995.                                 BPTR    OldDir,FileLock;
  996.                                 LONG    i;
  997.  
  998.                                 TransferProcess -> pr_WindowPtr = (APTR)-1;
  999.  
  1000.                                 LT_SetAttributes(Handle,GAD_LIST,
  1001.                                     GTLV_Labels,    ~0,
  1002.                                 TAG_DONE);
  1003.  
  1004.                                 for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1005.                                 {
  1006.                                     if(AppMessage -> am_ArgList[i] . wa_Name)
  1007.                                     {
  1008.                                         OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1009.  
  1010.                                         if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1011.                                         {
  1012.                                             if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1013.                                             {
  1014.                                                 if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1015.                                                 {
  1016.                                                     struct Node *Node;
  1017.  
  1018.                                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1019.                                                     {
  1020.                                                         Node -> ln_Name = (STRPTR)(Node + 1);
  1021.  
  1022.                                                         strcpy(Node -> ln_Name,DummyBuffer);
  1023.  
  1024.                                                         AddTail(TransferList,Node);
  1025.  
  1026.                                                         TransferCount++;
  1027.                                                     }
  1028.                                                 }
  1029.  
  1030.                                                 UnLock(FileLock);
  1031.                                             }
  1032.                                         }
  1033.  
  1034.                                         CurrentDir(OldDir);
  1035.                                     }
  1036.                                 }
  1037.  
  1038.                                 TransferProcess -> pr_WindowPtr = LocalWindow;
  1039.  
  1040.                                 LT_SetAttributes(Handle,GAD_LIST,
  1041.                                     GTLV_Labels,    TransferList,
  1042.                                 TAG_DONE);
  1043.  
  1044.                                 LT_SetAttributes(Handle,GAD_CLEAR,
  1045.                                     GA_Disabled,    !TransferCount,
  1046.                                 TAG_DONE);
  1047.  
  1048.                                 LT_SetAttributes(Handle,UPLOAD_BINARY,
  1049.                                     GA_Disabled,    !TransferCount,
  1050.                                 TAG_DONE);
  1051.  
  1052.                                 LT_SetAttributes(Handle,UPLOAD_TEXT,
  1053.                                     GA_Disabled,    !TransferCount,
  1054.                                 TAG_DONE);
  1055.                             }
  1056.  
  1057.                             if(AppMessage -> am_Type == AMTYPE_APPICON)
  1058.                             {
  1059.                                 if(AppMessage -> am_NumArgs)
  1060.                                 {
  1061.                                     UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1062.                                     BPTR    OldDir,FileLock;
  1063.                                     LONG    i;
  1064.  
  1065.                                     TransferProcess -> pr_WindowPtr = (APTR)-1;
  1066.  
  1067.                                     if(Handle)
  1068.                                     {
  1069.                                         LT_SetAttributes(Handle,GAD_LIST,
  1070.                                             GTLV_Labels,    ~0,
  1071.                                         TAG_DONE);
  1072.                                     }
  1073.  
  1074.                                     for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1075.                                     {
  1076.                                         if(AppMessage -> am_ArgList[i] . wa_Name)
  1077.                                         {
  1078.                                             OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1079.  
  1080.                                             if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1081.                                             {
  1082.                                                 if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1083.                                                 {
  1084.                                                     if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1085.                                                     {
  1086.                                                         struct Node *Node;
  1087.  
  1088.                                                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1089.                                                         {
  1090.                                                             Node -> ln_Name = (STRPTR)(Node + 1);
  1091.  
  1092.                                                             strcpy(Node -> ln_Name,DummyBuffer);
  1093.  
  1094.                                                             AddTail(TransferList,Node);
  1095.  
  1096.                                                             TransferCount++;
  1097.                                                         }
  1098.                                                     }
  1099.  
  1100.                                                     UnLock(FileLock);
  1101.                                                 }
  1102.                                             }
  1103.  
  1104.                                             CurrentDir(OldDir);
  1105.                                         }
  1106.                                     }
  1107.  
  1108.                                     if(Handle)
  1109.                                     {
  1110.                                         TransferProcess -> pr_WindowPtr = LocalWindow;
  1111.  
  1112.                                         LT_SetAttributes(Handle,GAD_LIST,
  1113.                                             GTLV_Labels,    TransferList,
  1114.                                         TAG_DONE);
  1115.  
  1116.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  1117.                                             GA_Disabled,    !TransferCount,
  1118.                                         TAG_DONE);
  1119.  
  1120.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  1121.                                             GA_Disabled,    !TransferCount,
  1122.                                         TAG_DONE);
  1123.  
  1124.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  1125.                                             GA_Disabled,    !TransferCount,
  1126.                                         TAG_DONE);
  1127.                                     }
  1128.                                     else
  1129.                                         TransferProcess -> pr_WindowPtr = OldPtr;
  1130.                                 }
  1131.                                 else
  1132.                                 {
  1133.                                     if(!Handle)
  1134.                                     {
  1135.                                         if(Handle = QueuePanel(NULL))
  1136.                                         {
  1137.                                             AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  1138.  
  1139.                                             LocalWindow = Handle -> Window;
  1140.  
  1141.                                             WindowMask = PORTMASK(LocalWindow -> UserPort);
  1142.  
  1143.                                             TransferProcess -> pr_WindowPtr = LocalWindow;
  1144.                                         }
  1145.                                     }
  1146.                                 }
  1147.                             }
  1148.  
  1149.                             ReplyMsg(AppMessage);
  1150.                         }
  1151.                     }
  1152.                 }
  1153.                 while(!Done);
  1154.  
  1155.                 if(AppIcon)
  1156.                     RemoveAppIcon(AppIcon);
  1157.  
  1158.                 if(AppWindow)
  1159.                     RemoveAppWindow(AppWindow);
  1160.  
  1161.                 if(LoadedIcon)
  1162.                     FreeDiskObject(LoadedIcon);
  1163.  
  1164.                 if(Handle)
  1165.                     LT_DeleteHandle(Handle);
  1166.  
  1167.                 while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1168.                     ReplyMsg(AppMessage);
  1169.             }
  1170.  
  1171.             DeleteMsgPort(TransferPort);
  1172.         }
  1173.  
  1174.         DeleteList(TransferList);
  1175.  
  1176.         TransferList = NULL;
  1177.     }
  1178.  
  1179.     Forbid();
  1180.  
  1181.     TransferProcess = NULL;
  1182.  
  1183.     Signal(ThisProcess,SIG_HANDSHAKE);
  1184. }
  1185.  
  1186.     /* CloseQueueWindow():
  1187.      *
  1188.      *    Close the queue window, wherever it may be.
  1189.      */
  1190.  
  1191. VOID
  1192. CloseQueueWindow()
  1193. {
  1194.     if(TransferProcess)
  1195.     {
  1196.         Forbid();
  1197.  
  1198.         ClrSignal(SIG_HANDSHAKE);
  1199.  
  1200.         Signal(TransferProcess,SIG_GOAWAY);
  1201.  
  1202.         Wait(SIG_HANDSHAKE);
  1203.  
  1204.         Permit();
  1205.     }
  1206. }
  1207.  
  1208.     /* DeleteQueueProcess():
  1209.      *
  1210.      *    Terminate the queue handler process.
  1211.      */
  1212.  
  1213. VOID
  1214. DeleteQueueProcess()
  1215. {
  1216.     if(TransferProcess)
  1217.     {
  1218.         Forbid();
  1219.  
  1220.         ClrSignal(SIG_HANDSHAKE);
  1221.  
  1222.         Signal(TransferProcess,SIG_KILL);
  1223.  
  1224.         Wait(SIG_HANDSHAKE);
  1225.  
  1226.         Permit();
  1227.     }
  1228. }
  1229.  
  1230.     /* CreateQueueProcess():
  1231.      *
  1232.      *    Create the queue handler process, if it's still around
  1233.      *    bring it to the front.
  1234.      */
  1235.  
  1236. BOOLEAN
  1237. CreateQueueProcess()
  1238. {
  1239.     if(!TransferProcess)
  1240.     {
  1241.         Forbid();
  1242.  
  1243.         if(CreateNewProcTags(
  1244.             NP_Entry,    QueueEntry,
  1245.             NP_Name,    "term Upload process",
  1246.             NP_Priority,    SysBase -> ThisTask -> tc_Node . ln_Pri,
  1247.             NP_StackSize,    6144,
  1248.             NP_WindowPtr,    NULL,
  1249.         TAG_DONE))
  1250.         {
  1251.             ClrSignal(SIG_HANDSHAKE);
  1252.  
  1253.             Wait(SIG_HANDSHAKE);
  1254.         }
  1255.  
  1256.         Permit();
  1257.     }
  1258.     else
  1259.         Signal(TransferProcess,SIG_SHOW);
  1260.  
  1261.     return((BOOLEAN)(TransferProcess != NULL));
  1262. }
  1263.  
  1264.     /* GetUploadList():
  1265.      *
  1266.      *    Copy the current upload list and return it.
  1267.      */
  1268.  
  1269. struct List *
  1270. GetUploadList()
  1271. {
  1272.     if(TransferProcess)
  1273.     {
  1274.         struct Message __aligned Message;
  1275.         struct MsgPort __aligned ReplyPort;
  1276.     
  1277.         InitSinglePort(&ReplyPort);
  1278.     
  1279.         Message . mn_Node . ln_Name    = (STRPTR)1;
  1280.         Message . mn_ReplyPort        = &ReplyPort;
  1281.         Message . mn_Length        = sizeof(struct Message);
  1282.     
  1283.         Forbid();
  1284.     
  1285.         PutMsg(TransferPort,&Message);
  1286.     
  1287.         ClrSignal(SIG_HANDSHAKE);
  1288.     
  1289.         Wait(SIG_HANDSHAKE);
  1290.     
  1291.         Permit();
  1292.  
  1293.         return((struct List *)Message . mn_Node . ln_Name);
  1294.     }
  1295.     else
  1296.         return(NULL);
  1297. }
  1298.  
  1299.     /* CheckUpload():
  1300.      *
  1301.      *    Check if there is anything in the upload list.
  1302.      */
  1303.  
  1304. BOOLEAN
  1305. CheckUpload()
  1306. {
  1307.     BOOLEAN Result = FALSE;
  1308.  
  1309.     if(TransferProcess)
  1310.     {
  1311.         struct Message __aligned Message;
  1312.         struct MsgPort __aligned ReplyPort;
  1313.  
  1314.         InitSinglePort(&ReplyPort);
  1315.  
  1316.         Message . mn_Node . ln_Name    = (APTR)~0;
  1317.         Message . mn_ReplyPort        = &ReplyPort;
  1318.         Message . mn_Length        = sizeof(struct Message);
  1319.  
  1320.         Forbid();
  1321.  
  1322.         PutMsg(TransferPort,&Message);
  1323.  
  1324.         ClrSignal(SIG_HANDSHAKE);
  1325.  
  1326.         Wait(SIG_HANDSHAKE);
  1327.  
  1328.         Permit();
  1329.  
  1330.         Result = (UBYTE)Message . mn_Node . ln_Name;
  1331.     }
  1332.  
  1333.     return(Result);
  1334. }
  1335.  
  1336.     /* StartUpload(UBYTE Type):
  1337.      *
  1338.      *    Start an upload the standard way.
  1339.      */
  1340.  
  1341. VOID __stdargs
  1342. StartUpload(UBYTE Type)
  1343. {
  1344.     if(TransferProcess)
  1345.     {
  1346.         struct Message __aligned Message;
  1347.         struct MsgPort __aligned ReplyPort;
  1348.  
  1349.         InitSinglePort(&ReplyPort);
  1350.  
  1351.         Message . mn_Node . ln_Name    = &Type;
  1352.         Message . mn_ReplyPort        = &ReplyPort;
  1353.         Message . mn_Length        = sizeof(struct Message);
  1354.  
  1355.         Forbid();
  1356.  
  1357.         PutMsg(TransferPort,&Message);
  1358.  
  1359.         ClrSignal(SIG_HANDSHAKE);
  1360.  
  1361.         Wait(SIG_HANDSHAKE);
  1362.  
  1363.         Permit();
  1364.     }
  1365. }
  1366.